<!DOCTYPE html>
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  <title>The source code</title>
  <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
  <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
  <style type="text/css">
    .highlight { display: block; background-color: #ddd; }
  </style>
  <script type="text/javascript">
    function highlight() {
      document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
    }
  </script>
</head>
<body onload="prettyPrint(); highlight();">
  <pre class="prettyprint lang-js"><span id='global-property-S-'>/**
</span> * @fileOverview 验证集合
 * @ignore
 */


var $ = require(&#39;jquery&#39;),
  Rule = require(&#39;./rule&#39;);

function toNumber(value){
  return parseFloat(value);
}

function toDate(value){
  return BUI.Date.parse(value);
}

var ruleMap = {

};

<span id='BUI-Form-Rules'>/**
</span> * @class BUI.Form.Rules
 * @singleton
 * 表单验证的验证规则管理器
 */
var rules = {
<span id='BUI-Form-Rules-method-add'>  /**
</span>   * 添加验证规则
   * @param {Object|BUI.Form.Rule} rule 验证规则配置项或者验证规则对象
   * @param  {String} name 规则名称
   */
  add : function(rule){
    var name;
    if($.isPlainObject(rule)){
      name = rule.name;
      ruleMap[name] = new Rule(rule);        
    }else if(rule.get){
      name = rule.get(&#39;name&#39;); 
      ruleMap[name] = rule;
    }
    return ruleMap[name];
  },
<span id='BUI-Form-Rules-method-remove'>  /**
</span>   * 删除验证规则
   * @param  {String} name 规则名称
   */
  remove : function(name){
    delete ruleMap[name];
  },
<span id='BUI-Form-Rules-method-get'>  /**
</span>   * 获取验证规则
   * @param  {String} name 规则名称
   * @return {BUI.Form.Rule}  验证规则
   */
  get : function(name){
    return ruleMap[name];
  },
<span id='BUI-Form-Rules-method-valid'>  /**
</span>   * 验证指定的规则
   * @param  {String} name 规则类型
   * @param  {*} value 验证值
   * @param  {*} [baseValue] 用于验证的基础值
   * @param  {String} [msg] 显示错误的模板
   * @param  {BUI.Form.Field|BUI.Form.Group} [control] 显示错误的模板
   * @return {String} 通过验证返回 null,否则返回错误信息
   */
  valid : function(name,value,baseValue,msg,control){
    var rule = rules.get(name);
    if(rule){
      return rule.valid(value,baseValue,msg,control);
    }
    return null;
  },
<span id='BUI-Form-Rules-method-isValid'>  /**
</span>   * 验证指定的规则
   * @param  {String} name 规则类型
   * @param  {*} values 验证值
   * @param  {*} [baseValue] 用于验证的基础值
   * @param  {BUI.Form.Field|BUI.Form.Group} [control] 显示错误的模板
   * @return {Boolean} 是否通过验证
   */
  isValid : function(name,value,baseValue,control){
    return rules.valid(name,value,baseValue,control) == null;
  }
};

<span id='BUI-Form-Rules-property-required'>/**
</span> * 非空验证,会对值去除空格
 * &lt;ol&gt;
 *  &lt;li&gt;name: required&lt;/li&gt;
 *  &lt;li&gt;msg: 不能为空！&lt;/li&gt;
 *  &lt;li&gt;required: boolean 类型&lt;/li&gt;
 * &lt;/ol&gt;
 * @member BUI.Form.Rules
 * @type {BUI.Form.Rule}
 */
var required = rules.add({
  name : &#39;required&#39;,
  msg : &#39;不能为空！&#39;,
  validator : function(value,required,formatedMsg){
    if(required !== false &amp;&amp; /^\s*$/.test(value)){
      return formatedMsg;
    }
  }
});

<span id='BUI-Form-Rules-property-equalTo'>/**
</span> * 相等验证
 * &lt;ol&gt;
 *  &lt;li&gt;name: equalTo&lt;/li&gt;
 *  &lt;li&gt;msg: 两次输入不一致！&lt;/li&gt;
 *  &lt;li&gt;equalTo: 一个字符串，id（#id_name) 或者 name&lt;/li&gt;
 * &lt;/ol&gt;
 *         {
 *           equalTo : &#39;#password&#39;
 *         }
 *         //或者
 *         {
 *           equalTo : &#39;password&#39;
 *         } 
 * @member BUI.Form.Rules
 * @type {BUI.Form.Rule}
 */
var equalTo = rules.add({
  name : &#39;equalTo&#39;,
  msg : &#39;两次输入不一致！&#39;,
  validator : function(value,equalTo,formatedMsg){
    var el = $(equalTo);
    if(el.length){
      equalTo = el.val();
    } 
    return value === equalTo ? undefined : formatedMsg;
  }
});


<span id='BUI-Form-Rules-property-min'>/**
</span> * 不小于验证
 * &lt;ol&gt;
 *  &lt;li&gt;name: min&lt;/li&gt;
 *  &lt;li&gt;msg: 输入值不能小于{0}！&lt;/li&gt;
 *  &lt;li&gt;min: 数字，字符串&lt;/li&gt;
 * &lt;/ol&gt;
 *         {
 *           min : 5
 *         }
 *         //字符串
 * @member BUI.Form.Rules
 * @type {BUI.Form.Rule}
 */
var min = rules.add({
  name : &#39;min&#39;,
  msg : &#39;输入值不能小于{0}！&#39;,
  validator : function(value,min,formatedMsg){
    if(BUI.isString(value)){
      value = value.replace(/\,/g,&#39;&#39;);
    }
    if(value !== &#39;&#39; &amp;&amp; toNumber(value) &lt; toNumber(min)){
      return formatedMsg;
    }
  }
});

<span id='BUI-Form-Rules-property-max'>/**
</span> * 不小于验证,用于数值比较
 * &lt;ol&gt;
 *  &lt;li&gt;name: max&lt;/li&gt;
 *  &lt;li&gt;msg: 输入值不能大于{0}！&lt;/li&gt;
 *  &lt;li&gt;max: 数字、字符串&lt;/li&gt;
 * &lt;/ol&gt;
 *         {
 *           max : 100
 *         }
 *         //字符串
 *         {
 *           max : &#39;100&#39;
 *         }
 * @member BUI.Form.Rules
 * @type {BUI.Form.Rule}
 */
var max = rules.add({
  name : &#39;max&#39;,
  msg : &#39;输入值不能大于{0}！&#39;,
  validator : function(value,max,formatedMsg){
    if(BUI.isString(value)){
      value = value.replace(/\,/g,&#39;&#39;);
    }
    if(value !== &#39;&#39; &amp;&amp; toNumber(value) &gt; toNumber(max)){
      return formatedMsg;
    }
  }
});

<span id='BUI-Form-Rules-property-length'>/**
</span> * 输入长度验证，必须是指定的长度
 * &lt;ol&gt;
 *  &lt;li&gt;name: length&lt;/li&gt;
 *  &lt;li&gt;msg: 输入值长度为{0}！&lt;/li&gt;
 *  &lt;li&gt;length: 数字&lt;/li&gt;
 * &lt;/ol&gt;
 * @member BUI.Form.Rules
 * @type {BUI.Form.Rule}
 */
var length = rules.add({
  name : &#39;length&#39;,
  msg : &#39;输入值长度为{0}！&#39;,
  validator : function(value,len,formatedMsg){
    if(value != null){
      value = $.trim(value.toString());
      if(len != value.length){
        return formatedMsg;
      }
    }
  }
});
<span id='BUI-Form-Rules-property-minlength'>/**
</span> * 最短长度验证,会对值去除空格
 * &lt;ol&gt;
 *  &lt;li&gt;name: minlength&lt;/li&gt;
 *  &lt;li&gt;msg: 输入值长度不小于{0}！&lt;/li&gt;
 *  &lt;li&gt;minlength: 数字&lt;/li&gt;
 * &lt;/ol&gt;
 *         {
 *           minlength : 5
 *         }
 * @member BUI.Form.Rules
 * @type {BUI.Form.Rule}
 */
var minlength = rules.add({
  name : &#39;minlength&#39;,
  msg : &#39;输入值长度不小于{0}！&#39;,
  validator : function(value,min,formatedMsg){
    if(value != null){
      value = $.trim(value.toString());
      var len = value.length;
      if(len &lt; min){
        return formatedMsg;
      }
    }
  }
});

<span id='BUI-Form-Rules-property-maxlength'>/**
</span> * 最短长度验证,会对值去除空格
 * &lt;ol&gt;
 *  &lt;li&gt;name: maxlength&lt;/li&gt;
 *  &lt;li&gt;msg: 输入值长度不大于{0}！&lt;/li&gt;
 *  &lt;li&gt;maxlength: 数字&lt;/li&gt;
 * &lt;/ol&gt;
 *         {
 *           maxlength : 10
 *         }
 * @member BUI.Form.Rules
 * @type {BUI.Form.Rule}   
 */
var maxlength = rules.add({
  name : &#39;maxlength&#39;,
  msg : &#39;输入值长度不大于{0}！&#39;,
  validator : function(value,max,formatedMsg){
    if(value){
      value = $.trim(value.toString());
      var len = value.length;
      if(len &gt; max){
        return formatedMsg;
      }
    }
  }
});

<span id='BUI-Form-Rules-property-regexp'>/**
</span> * 正则表达式验证,如果正则表达式为空，则不进行校验
 * &lt;ol&gt;
 *  &lt;li&gt;name: regexp&lt;/li&gt;
 *  &lt;li&gt;msg: 输入值不符合{0}！&lt;/li&gt;
 *  &lt;li&gt;regexp: 正则表达式&lt;/li&gt;
 * &lt;/ol&gt; 
 * @member BUI.Form.Rules
 * @type {BUI.Form.Rule}
 */
var regexp = rules.add({
  name : &#39;regexp&#39;,
  msg : &#39;输入值不符合{0}！&#39;,
  validator : function(value,regexp,formatedMsg){
    if(regexp){
      return regexp.test(value) ? undefined : formatedMsg;
    }
  }
});

<span id='BUI-Form-Rules-property-email'>/**
</span> * 邮箱验证,会对值去除空格，无数据不进行校验
 * &lt;ol&gt;
 *  &lt;li&gt;name: email&lt;/li&gt;
 *  &lt;li&gt;msg: 不是有效的邮箱地址！&lt;/li&gt;
 * &lt;/ol&gt;
 * @member BUI.Form.Rules
 * @type {BUI.Form.Rule}
 */
var email = rules.add({
  name : &#39;email&#39;,
  msg : &#39;不是有效的邮箱地址！&#39;,
  validator : function(value,baseValue,formatedMsg){
    value = $.trim(value);
    if(value){
      return /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/.test(value) ? undefined : formatedMsg;
    }
  }
});

<span id='BUI-Form-Rules-property-date'>/**
</span> * 日期验证，会对值去除空格，无数据不进行校验，
 * 如果传入的值不是字符串，而是数字，则认为是有效值
 * &lt;ol&gt;
 *  &lt;li&gt;name: date&lt;/li&gt;
 *  &lt;li&gt;msg: 不是有效的日期！&lt;/li&gt;
 * &lt;/ol&gt;
 * @member BUI.Form.Rules
 * @type {BUI.Form.Rule}
 */
var date = rules.add({
  name : &#39;date&#39;,
  msg : &#39;不是有效的日期！&#39;,
  validator : function(value,baseValue,formatedMsg){
    if(BUI.isNumber(value)){ //数字认为是日期
      return;
    }
    if(BUI.isDate(value)){
      return;
    }
    value = $.trim(value);
    if(value){
      return BUI.Date.isDateString(value) ? undefined : formatedMsg;
    }
  }
});

<span id='BUI-Form-Rules-property-minDate'>/**
</span> * 不小于验证
 * &lt;ol&gt;
 *  &lt;li&gt;name: minDate&lt;/li&gt;
 *  &lt;li&gt;msg: 输入日期不能小于{0}！&lt;/li&gt;
 *  &lt;li&gt;minDate: 日期，字符串&lt;/li&gt;
 * &lt;/ol&gt;
 *         {
 *           minDate : &#39;2001-01-01&#39;;
 *         }
 *         //字符串
 * @member BUI.Form.Rules
 * @type {BUI.Form.Rule}
 */
var minDate = rules.add({
  name : &#39;minDate&#39;,
  msg : &#39;输入日期不能小于{0}！&#39;,
  validator : function(value,minDate,formatedMsg){
    if(value){
      var date = toDate(value);
      if(date &amp;&amp; date &lt; toDate(minDate)){
         return formatedMsg;
      }
    }
  }
});

<span id='BUI-Form-Rules-property-maxDate'>/**
</span> * 不小于验证,用于数值比较
 * &lt;ol&gt;
 *  &lt;li&gt;name: maxDate&lt;/li&gt;
 *  &lt;li&gt;msg: 输入值不能大于{0}！&lt;/li&gt;
 *  &lt;li&gt;maxDate: 日期、字符串&lt;/li&gt;
 * &lt;/ol&gt;
 *         {
 *           maxDate : &#39;2001-01-01&#39;;
 *         }
 *         //或日期
 *         {
 *           maxDate : new Date(&#39;2001-01-01&#39;);
 *         }
 * @member BUI.Form.Rules
 * @type {BUI.Form.Rule}
 */
var maxDate = rules.add({
  name : &#39;maxDate&#39;,
  msg : &#39;输入日期不能大于{0}！&#39;,
  validator : function(value,maxDate,formatedMsg){
    if(value){
      var date = toDate(value);
      if(date &amp;&amp; date &gt; toDate(maxDate)){
         return formatedMsg;
      }
    }
  }
});

<span id='BUI-Form-Rules-property-mobile'>/**
</span> * 手机验证，11位手机数字
 * &lt;ol&gt;
 *  &lt;li&gt;name: mobile&lt;/li&gt;
 *  &lt;li&gt;msg: 不是有效的手机号码！&lt;/li&gt;
 * &lt;/ol&gt;
 * @member BUI.Form.Rules
 * @type {BUI.Form.Rule}
 */
var mobile = rules.add({
  name : &#39;mobile&#39;,
  msg : &#39;不是有效的手机号码！&#39;,
  validator : function(value,baseValue,formatedMsg){
    value = $.trim(value);
    if(value){
      return /^\d{11}$/.test(value) ? undefined : formatedMsg;
    }
  }
});

<span id='BUI-Form-Rules-property-number'>/**
</span> * 数字验证，会对值去除空格，无数据不进行校验
 * 允许千分符，例如： 12,000,000的格式
 * &lt;ol&gt;
 *  &lt;li&gt;name: number&lt;/li&gt;
 *  &lt;li&gt;msg: 不是有效的数字！&lt;/li&gt;
 * &lt;/ol&gt;
 * @member BUI.Form.Rules
 * @type {BUI.Form.Rule}
 */
var number = rules.add({
  name : &#39;number&#39;,
  msg : &#39;不是有效的数字！&#39;,
  validator : function(value,baseValue,formatedMsg){
    if(BUI.isNumber(value)){
      return;
    }
    value = value.replace(/\,/g,&#39;&#39;);
    return !isNaN(value) ? undefined : formatedMsg;
  }
});

//测试范围
function testRange (baseValue,curVal,prevVal) {
  var allowEqual = baseValue &amp;&amp; (baseValue.equals !== false);

  if(allowEqual){
    return prevVal &lt;= curVal;
  }

  return prevVal &lt; curVal;
}
function isEmpty(value){
  return value == &#39;&#39; || value == null;
}
//测试是否后面的数据大于前面的
function rangeValid(value,baseValue,formatedMsg,group){
  var fields = group.getFields(),
    valid = true;
  for(var i = 1; i &lt; fields.length ; i ++){
    var cur = fields[i],
      prev = fields[i-1],
      curVal,
      prevVal;
    if(cur &amp;&amp; prev){
      curVal = cur.get(&#39;value&#39;);
      prevVal = prev.get(&#39;value&#39;);
      if(!isEmpty(curVal) &amp;&amp; !isEmpty(prevVal) &amp;&amp; !testRange(baseValue,curVal,prevVal)){
        valid = false;
        break;
      }
    }
  }
  if(!valid){
    return formatedMsg;
  }
  return null;
}
<span id='BUI-Form-Rules-property-dateRange'>/**
</span> * 起始结束日期验证，前面的日期不能大于后面的日期
 * &lt;ol&gt;
 *  &lt;li&gt;name: dateRange&lt;/li&gt;
 *  &lt;li&gt;msg: 起始日期不能大于结束日期！&lt;/li&gt;
 *  &lt;li&gt;dateRange: 可以使true或者{equals : fasle}，标示是否允许相等&lt;/li&gt;
 * &lt;/ol&gt;
 *         {
 *           dateRange : true
 *         }
 *         {
 *           dateRange : {equals : false}
 *         }
 * @member BUI.Form.Rules
 * @type {BUI.Form.Rule}   
 */
var dateRange = rules.add({
  name : &#39;dateRange&#39;,
  msg : &#39;结束日期不能小于起始日期！&#39;,
  validator : rangeValid
});

<span id='BUI-Form-Rules-property-numberRange'>/**
</span> * 数字范围
 * &lt;ol&gt;
 *  &lt;li&gt;name: numberRange&lt;/li&gt;
 *  &lt;li&gt;msg: 起始数字不能大于结束数字！&lt;/li&gt;
 *  &lt;li&gt;numberRange: 可以使true或者{equals : fasle}，标示是否允许相等&lt;/li&gt;
 * &lt;/ol&gt;
 *         {
 *           numberRange : true
 *         }
 *         {
 *           numberRange : {equals : false}
 *         }
 * @member BUI.Form.Rules
 * @type {BUI.Form.Rule}   
 */
var numberRange = rules.add({
  name : &#39;numberRange&#39;,
  msg : &#39;结束数字不能小于开始数字！&#39;,
  validator : rangeValid
});

function getFieldName (self) {
  var firstField = self.getFieldAt(0);
  if(firstField){
    return firstField.get(&#39;name&#39;);
  }
  return &#39;&#39;;
}

function testCheckRange(value,range){
  if(!BUI.isArray(range)){
    range = [range];
  }
  //不存在值
  if(!value || !range.length){
    return false;
  }
  var len = !value ? 0 : !BUI.isArray(value) ? 1 : value.length;
  //如果只有一个限定值
  if(range.length == 1){
    var number = range [0];
    if(!number){//range = [0],则不必选
      return true;
    }
    if(number &gt; len){
      return false;
    }
  }else{
    var min = range [0],
      max = range[1];
    if(min &gt; len || max &lt; len){
      return false;
    }
  }
  return true;
}

<span id='BUI-Form-Rules-property-checkRange'>/**
</span> * 勾选的范围
 * &lt;ol&gt;
 *  &lt;li&gt;name: checkRange&lt;/li&gt;
 *  &lt;li&gt;msg: 必须选中{0}项！&lt;/li&gt;
 *  &lt;li&gt;checkRange: 勾选的项范围&lt;/li&gt;
 * &lt;/ol&gt;
 *         //至少勾选一项
 *         {
 *           checkRange : 1
 *         }
 *         //只能勾选两项
 *         {
 *           checkRange : [2,2]
 *         }
 *         //可以勾选2-4项
 *         {
 *           checkRange : [2,4
 *           ]
 *         }
 * @member BUI.Form.Rules
 * @type {BUI.Form.Rule}   
 */
var checkRange = rules.add({
  name : &#39;checkRange&#39;,
  msg : &#39;必须选中{0}项！&#39;,
  validator : function(record,baseValue,formatedMsg,group){
    var name = getFieldName(group),
      value,
      range = baseValue;
      
    if(name &amp;&amp; range){
      value = record[name];
      if(!testCheckRange(value,range)){
        return formatedMsg;
      }
    }
    return null;
  }
});

module.exports = rules;
</pre>
</body>
</html>
